Instance 0

Class100.create3LightsYellowImage(final int WIDTH,final int HEIGHT,final boolean IS_ON)#1{
            final Ellipse2D OFF = new Ellipse2D.Double(0.1875 * IMAGE_WIDTH, 0.38 * IMAGE_HEIGHT, 0.625 * IMAGE_WIDTH, 0.25 * IMAGE_HEIGHT);
            G2.setPaint(new RadialGradientPaint(new Point2D.Double(0.5 * IMAGE_WIDTH, 0.585 * IMAGE_HEIGHT), (0.59375f * IMAGE_WIDTH), new float[]{0.0f, 0.98f, 0.99f, 1.0f}, new Color[]{new Color(0.3254901961f, 0.3333333333f, 0f, 1f), new Color(0.0039215686f, 0.0039215686f, 0f, 1f), new Color(0f, 0f, 0f, 1f), new Color(0f, 0f, 0f, 1f)}));
            G2.fill(OFF);
            final Ellipse2D HIGHLIGHT_OFF = new Ellipse2D.Double(0.2625 * IMAGE_WIDTH, 0.385 * IMAGE_HEIGHT, 0.4625 * IMAGE_WIDTH, 0.1 * IMAGE_HEIGHT);
            G2.setPaint(new RadialGradientPaint(new Point2D.Double(0.5 * IMAGE_WIDTH, 0.405 * IMAGE_HEIGHT), (0.2125f * IMAGE_WIDTH), new float[]{0.0f, 0.98f, 1.0f}, new Color[]{new Color(1f, 1f, 1f, 0.2235294118f), new Color(1f, 1f, 1f, 0.0274509804f), new Color(1f, 1f, 1f, 0.0274509804f)}));
            G2.fill(HIGHLIGHT_OFF);
            final Ellipse2D GLOW = new Ellipse2D.Double(0.0 * IMAGE_WIDTH, 0.3 * IMAGE_HEIGHT, 1.0 * IMAGE_WIDTH, 0.4 * IMAGE_HEIGHT);
            G2.setPaint(new RadialGradientPaint(new Point2D.Double(0.5 * IMAGE_WIDTH, 0.5 * IMAGE_HEIGHT), (0.5f * IMAGE_WIDTH), new float[]{0.0f, 0.98f, 0.99f, 1.0f}, new Color[]{new Color(1f, 1f, 0f, 1f), new Color(1f, 1f, 0f, 0f), new Color(1f, 1f, 0f, 0f), new Color(1f, 1f, 0f, 0f)}));
            G2.fill(GLOW);
            final Ellipse2D ON = new Ellipse2D.Double(0.1875 * IMAGE_WIDTH, 0.38 * IMAGE_HEIGHT, 0.625 * IMAGE_WIDTH, 0.25 * IMAGE_HEIGHT);
            G2.setPaint(new RadialGradientPaint(new Point2D.Double(0.5 * IMAGE_WIDTH, 0.585 * IMAGE_HEIGHT), (0.59375f * IMAGE_WIDTH), new float[]{0.0f, 0.98f, 0.99f, 1.0f}, new Color[]{new Color(1f, 1f, 0f, 1f), new Color(0.3333333333f, 0.3411764706f, 0f, 1f), new Color(0.3254901961f, 0.3333333333f, 0f, 1f), new Color(0.3254901961f, 0.3333333333f, 0f, 1f)}));
            G2.fill(ON);
            final Ellipse2D HIGHLIGHT_ON = new Ellipse2D.Double(0.2625 * IMAGE_WIDTH, 0.385 * IMAGE_HEIGHT, 0.4625 * IMAGE_WIDTH, 0.1 * IMAGE_HEIGHT);
            G2.setPaint(new RadialGradientPaint(new Point2D.Double(0.5 * IMAGE_WIDTH, 0.405 * IMAGE_HEIGHT), (0.2125f * IMAGE_WIDTH), new float[]{0.0f, 0.98f, 1.0f}, new Color[]{new Color(1f, 1f, 1f, 0.6745098039f), new Color(1f, 1f, 1f, 0.0862745098f), new Color(1f, 1f, 1f, 0.0862745098f)}));
            G2.fill(HIGHLIGHT_ON);
        final Ellipse2D INNER_SHADOW = new Ellipse2D.Double(0.1875 * IMAGE_WIDTH, 0.38 * IMAGE_HEIGHT, 0.625 * IMAGE_WIDTH, 0.25 * IMAGE_HEIGHT);
        G2.setPaint(new RadialGradientPaint(new Point2D.Double(0.5 * IMAGE_WIDTH, 0.505 * IMAGE_HEIGHT), (0.3125f * IMAGE_WIDTH), new float[]{0.0f, 0.55f, 0.5501f, 0.78f, 0.79f, 1.0f}, new Color[]{new Color(0.0039215686f, 0.0039215686f, 0.0039215686f, 0f), new Color(0f, 0f, 0f, 0f), new Color(0f, 0f, 0f, 0f), new Color(0f, 0f, 0f, 0.1215686275f), new Color(0f, 0f, 0f, 0.1294117647f), new Color(0f, 0f, 0f, 0.4980392157f)}));
        G2.fill(INNER_SHADOW);
        G2.dispose();
}


Instance 1

Class660.paintComponent(Graphics graphics)#0{
        r = new Rectangle(- 5, - 5, 10, 10);
        g.fill(r);
        r = new Rectangle(w / 4 - 5, h / 4 - 5, 10, 10);
        g.fill(r);
        r = new Rectangle(w / 4 - 5, - h / 4 - 5, 10, 10);
        g.fill(r);
        r = new Rectangle(- w / 4 - 5, h / 4 - 5, 10, 10);
        g.fill(r);
        r = new Rectangle(- w / 4 - 5, - h / 4 - 5, 10, 10);
        g.fill(r);
}


Instance 2

Class680.drawHandledRect(Graphics2D graphics,Rectangle2D rect,double handleSize)#0{
    Rectangle2D hr = new Rectangle2D.Double();
    hr.setRect(x - handleSize/2, y - handleSize/2, handleSize, handleSize);
    graphics.fill( hr);
    hr.setRect(x + w - handleSize/2, y - handleSize/2, handleSize, handleSize);
    graphics.fill( hr);
    hr.setRect(x - handleSize/2, y + h - handleSize/2, handleSize, handleSize);
    graphics.fill( hr);
    hr.setRect(x + w - handleSize/2, y + h - handleSize/2, handleSize, handleSize);
    graphics.fill( hr);
}


Instance 3

Class570.paintBackgroundEnabled(Graphics2D g)#0{
    g.setPaint(color14);
    g.fill(path);
    path = decodePath2();
    g.setPaint(decodeGradient5(path));
    g.fill(path);
    path = decodePath3();
    g.setPaint(decodeGradient6(path));
    g.fill(path);
    path = decodePath4();
    g.setPaint(decodeGradient7(path));
    g.fill(path);
    path = decodePath5();
    g.setPaint(decodeGradient8(path));
    g.fill(path);
}


Instance 4

Class570.paintBackgroundDisabled(Graphics2D g)#0{
    g.setPaint(color1);
    g.fill(path);
    path = decodePath2();
    g.setPaint(decodeGradient1(path));
    g.fill(path);
    path = decodePath3();
    g.setPaint(decodeGradient2(path));
    g.fill(path);
    path = decodePath4();
    g.setPaint(decodeGradient3(path));
    g.fill(path);
    path = decodePath5();
    g.setPaint(decodeGradient4(path));
    g.fill(path);
}


Instance 5

Class260.draw(Graphics2D g2,Rectangle2D area)#0{
        if (t > 0.0) {
            rect.setRect(x, y, w, t);
            g2.fill(rect);
        }
        if (b > 0.0) {
            rect.setRect(x, y + h - b, w, b);
            g2.fill(rect);
        }
        if (l > 0.0) {
            rect.setRect(x, y, l, h);
            g2.fill(rect);
        }
        if (r > 0.0) {
            rect.setRect(x + w - r, y, r, h);
            g2.fill(rect);
        }
}


Instance 6

Class490.createRedLightImage(final int WIDTH,final int HEIGHT)#1{
        final int IMAGE_WIDTH = IMAGE.getWidth();
        final int IMAGE_HEIGHT = IMAGE.getHeight();
        final Ellipse2D FRAME = new Ellipse2D.Double(0.10204081632653061 * IMAGE_WIDTH, 0.046762589928057555 * IMAGE_HEIGHT, 0.7959183673469388 * IMAGE_WIDTH, 0.2805755395683453 * IMAGE_HEIGHT);
        G2.setPaint(new LinearGradientPaint(new Point2D.Double(0.5 * IMAGE_WIDTH, 0.046762589928057555 * IMAGE_HEIGHT), new Point2D.Double(0.5 * IMAGE_WIDTH, 0.3273381294964029 * IMAGE_HEIGHT), new float[]{0.0f, 0.05f, 0.1f, 0.17f, 0.27f, 1.0f}, new Color[]{new Color(1f, 1f, 1f, 1f), new Color(0.8f, 0.8f, 0.8f, 1f), new Color(0.6f, 0.6f, 0.6f, 1f), new Color(0.4f, 0.4f, 0.4f, 1f), new Color(0.2f, 0.2f, 0.2f, 1f), new Color(0.0039215686f, 0.0039215686f, 0.0039215686f, 1f)}));
        G2.fill(FRAME);
        final Ellipse2D INNER_CLIP = new Ellipse2D.Double(0.10204081632653061 * IMAGE_WIDTH, 0.0683453237410072 * IMAGE_HEIGHT, 0.7959183673469388 * IMAGE_WIDTH, 0.2589928057553957 * IMAGE_HEIGHT);
        G2.setPaint(new LinearGradientPaint(new Point2D.Double(0.5 * IMAGE_WIDTH, 0.0683453237410072 * IMAGE_HEIGHT), new Point2D.Double(0.5 * IMAGE_WIDTH, 0.3273381294964029 * IMAGE_HEIGHT), new float[]{0.0f, 0.35f, 0.66f, 1.0f}, new Color[]{new Color(0f, 0f, 0f, 1f), new Color(0.0156862745f, 0.0156862745f, 0.0156862745f, 1f), new Color(0f, 0f, 0f, 1f), new Color(0.0039215686f, 0.0039215686f, 0.0039215686f, 1f)}));
        G2.fill(INNER_CLIP);
        final Ellipse2D LIGHT_EFFECT = new Ellipse2D.Double(0.14285714285714285 * IMAGE_WIDTH, 0.06474820143884892 * IMAGE_HEIGHT, 0.7142857142857143 * IMAGE_WIDTH, 0.2517985611510791 * IMAGE_HEIGHT);
        G2.setPaint(new RadialGradientPaint(new Point2D.Double(0.5 * IMAGE_WIDTH, 0.1906474820143885 * IMAGE_HEIGHT), (0.3622448979591837f * IMAGE_WIDTH), new float[]{0.0f, 0.88f, 0.95f, 1.0f}, new Color[]{new Color(0f, 0f, 0f, 1f), new Color(0f, 0f, 0f, 1f), new Color(0.3686274510f, 0.3686274510f, 0.3686274510f, 1f), new Color(0.0039215686f, 0.0039215686f, 0.0039215686f, 1f)}));
        G2.fill(LIGHT_EFFECT);
        final Ellipse2D INNER_SHADOW = new Ellipse2D.Double(0.14285714285714285 * IMAGE_WIDTH, 0.06474820143884892 * IMAGE_HEIGHT, 0.7142857142857143 * IMAGE_WIDTH, 0.2517985611510791 * IMAGE_HEIGHT);
        G2.setPaint(new LinearGradientPaint(new Point2D.Double(0.5 * IMAGE_WIDTH, 0.0683453237410072 * IMAGE_HEIGHT), new Point2D.Double(0.5 * IMAGE_WIDTH, 0.29856115107913667 * IMAGE_HEIGHT), new float[]{0.0f, 1.0f}, new Color[]{new Color(0f, 0f, 0f, 1f), new Color(0.0039215686f, 0.0039215686f, 0.0039215686f, 0f)}));
        G2.fill(INNER_SHADOW);
        G2.dispose();
}


Instance 7

Class570.paintBackgroundMouseOverAndFocused(Graphics2D g)#0{
    path = decodePath2();
    g.setPaint(decodeGradient9(path));
    g.fill(path);
    path = decodePath3();
    g.setPaint(decodeGradient6(path));
    g.fill(path);
    path = decodePath4();
    g.setPaint(decodeGradient10(path));
    g.fill(path);
    path = decodePath5();
    g.setPaint(decodeGradient8(path));
    g.fill(path);
}


Instance 8

Class500.drawComponentSelectionBox(Graphics2D g,LWComponent c)#0{
        if (CHS % 2 == 0) {
            // if box size is even, bias to inside the selection border
            r.height--;
            r.width--;
        }
        ComponentHandle.setFrame(r.x, r.y , CHS, CHS);
        g.fill(ComponentHandle);
        ComponentHandle.setFrame(r.x, r.y + r.height, CHS, CHS);
        g.fill(ComponentHandle);
        ComponentHandle.setFrame(r.x + r.width, r.y, CHS, CHS);
        g.fill(ComponentHandle);
        ComponentHandle.setFrame(r.x + r.width, r.y + r.height, CHS, CHS);
        g.fill(ComponentHandle);
}


Instance 9

Class710.replay(final WmfFile file)#1{
      graph.fill( rect );
      rect.setFrame( rec.x, rec.y - dim.height, rec.width, dim.height );
      graph.fill( rect );
      rect.setFrame( rec.x, rec.y, dim.width, rec.height );
      graph.fill( rect );
      rect.setFrame( rec.width - dim.width, rec.y, dim.width, rec.height );
      graph.fill( rect );
}


Instance 10

Class390.paintImage(Graphics2D g2d,Color color1,Color color2,Color color3)#0{
        Color bcolor = new Color(1f, 1f, 1f, 0f);
        g2d.setBackground(bcolor);
        g2d.setColor(color1);
        g2d.fill(path);
        g2d.clearRect(0, 16, 40, 8);
        g2d.setColor(color2);
        g2d.translate(0, 128);
        g2d.fill(path);
        g2d.clearRect(0, 16, 40, 8);
        g2d.setColor(color3);
        g2d.translate(0, 128);
        g2d.fill(path);
        g2d.clearRect(0, 16, 40, 8);
}


Instance 11

Class200.createTriangles(Color c)#1{
        g2.fill(new Polygon(new int[] {0, a/2, a}, new int[] {0, b/2, 0}, 3));
        g2.fill(new Polygon(new int[] {0, a/2, 0}, new int[] {b/2, b/2, b}, 3));
        g2.fill(new Polygon(new int[] {a, a/2, a}, new int[] {b/2, b/2, b}, 3));
        return new TexturePaint(bi, new Rectangle(0, 0, a, b));
}


Instance 12

Class260.debugVisibleArea(Graphics2D g)#1{
    ellipse.setFrame(camera.getViewCenter().x - 3 * px1,
        camera.getViewCenter().y - 3 * px1, px1 * 6, px1 * 6);
    g.fill(ellipse);
    ellipse.setFrame(metrics.lo.x - 3 * px1, metrics.lo.y - 3 * px1,
        px1 * 6, px1 * 6);
    g.fill(ellipse);
    ellipse.setFrame(metrics.hi.x - 3 * px1, metrics.hi.y - 3 * px1,
        px1 * 6, px1 * 6);
    g.fill(ellipse);
}


Instance 13

Class290.drawModel(Graphics2D g2d)#0{
                    g2d.setColor(new Color(255, 200, 200));
                    g2d.setColor(new Color(200, 200, 255));
                g2d.fill(face.outline);
                g2d.setColor(Color.WHITE);
                g2d.fill(face.outline);
                g2d.setColor(new Color(100, 100, 100));
                g2d.fill(face.outline);
            g2d.setColor(Color.BLACK);
}


Instance 14

Class570.paintBackgroundDisabled(Graphics2D g)#0{
    g.setPaint(color1);
    g.fill(rect);
    rect = decodeRect2();
    g.setPaint(decodeGradient1(rect));
    g.fill(rect);
    rect = decodeRect3();
    g.setPaint(decodeGradient2(rect));
    g.fill(rect);
    rect = decodeRect4();
}


Instance 15

Class380.paintImage(Graphics2D g2d,Color color1,Color color2,Color color3)#0{
        Dimension dimension = getDimension();
        g2d.scale(dimension.getWidth() / 128, dimension.getWidth() / 128);
        draw(path, g2d);
        g2d.setColor(color1);
        g2d.fill(path);
        g2d.setColor(color2);
        g2d.translate(0, 128);
        g2d.fill(path);
        g2d.setColor(color3);
        g2d.translate(0, 128);
        g2d.fill(path);
}


Instance 16

Class330.paintObject(Graphics2D g2,State s,ObjectInstance ob,float cWidth,float cHeight)#0{
      g2.fill(new Rectangle2D.Double(x, y, size, size));
      if (x + size > FrostbiteDomain.gameWidth)
        g2.fill(new Rectangle2D.Double(x - FrostbiteDomain.gameWidth, y, size, size));
      else if (x < 0)
        g2.fill(new Rectangle2D.Double(x + FrostbiteDomain.gameWidth, y, size, size));
}


Instance 17

Class130.paintButtonBackground(Graphics g,AbstractButton b)#2{
          RoundRectangle2D rect = new RoundRectangle2D.Float(0, 0,
              width, height, link.getBtnGroup().getArc(), arc);
          g2.setColor(b.getBackground());
          g2.fill(rect);
          Rectangle2D rectFix = new Rectangle((int) width - arc, 0,
              (int) arc, (int) height);
          g2.fill(rectFix);
          g2.dispose();
}


Instance 18

Class120.paintFocus(Graphics g,AbstractButton b,Rectangle viewRect,Rectangle textRect,Rectangle iconRect)#1{
        g2.setColor(getFocusColor());
        g2.fill(rect);
        Rectangle2D rectFix = new Rectangle((int) width - arc, 0,
            (int) arc, (int) height);
        g2.fill(rectFix);
        g2.dispose();
}


Instance 19

Class150.paint(Graphics2D g2)#1{
                g2.setPaint(textures.createMultiColor(fh.colors));
                g2.fill(area);
                g2.setPaint(textures.create(fh.colors[0]));
                g2.fill(area);
        g2.setPaint(null);
        g2.setComposite(old);
}


Instance 20

Class570.doPaint(Graphics2D g,JComponent c,int width,int height,Object[] extendedCacheKeys)#1{
            g.setColor(SkinColors.SCROLL_THUMB_BORDER_COLOR);
            g.fill(s1);
            Shape s2 = shapeGenerator.createRectangle(1, 1, width - 2, height - 1);
            g.setPaint(getScrollBarThumbPaint(s2));
            g.fill(s2);
}


Instance 21

Class330.createRedOffImage(final int WIDTH,final int HEIGHT)#1{
        final int IMAGE_WIDTH = IMAGE.getWidth();
        final int IMAGE_HEIGHT = IMAGE.getHeight();
        final Ellipse2D LIGHT_OFF = new Ellipse2D.Double(0.17346938775510204 * IMAGE_WIDTH, 0.07553956834532374 * IMAGE_HEIGHT, 0.6530612244897959 * IMAGE_WIDTH, 0.2302158273381295 * IMAGE_HEIGHT);
        G2.setPaint(new RadialGradientPaint(new Point2D.Double(0.5 * IMAGE_WIDTH, 0.1906474820143885 * IMAGE_HEIGHT), (0.32653061224489793f * IMAGE_WIDTH), new float[]{0.0f, 1.0f}, new Color[]{new Color(1f, 0f, 0f, 0.2470588235f), new Color(1f, 0f, 0f, 0.0470588235f)}));
        G2.fill(LIGHT_OFF);
        final Ellipse2D INNER_SHADOW = new Ellipse2D.Double(0.17346938775510204 * IMAGE_WIDTH, 0.07553956834532374 * IMAGE_HEIGHT, 0.6530612244897959 * IMAGE_WIDTH, 0.2302158273381295 * IMAGE_HEIGHT);
        G2.setPaint(new RadialGradientPaint(new Point2D.Double(0.5 * IMAGE_WIDTH, 0.1906474820143885 * IMAGE_HEIGHT), (0.32653061224489793f * IMAGE_WIDTH), new float[]{0.0f, 0.55f, 0.5501f, 0.78f, 0.79f, 1.0f}, new Color[]{new Color(0.0039215686f, 0.0039215686f, 0.0039215686f, 0f), new Color(0f, 0f, 0f, 0f), new Color(0f, 0f, 0f, 0f), new Color(0f, 0f, 0f, 0.1215686275f), new Color(0f, 0f, 0f, 0.1294117647f), new Color(0f, 0f, 0f, 0.4980392157f)}));
        G2.fill(INNER_SHADOW);
}


Instance 22

Class230.paintComponent(final Graphics g)#1{
        final Shape rf2 = new Rectangle2D.Float(0.0f, 0.0f, getWidth(), getHeight());
        final Shape rf1 = new Rectangle2D.Float(3.0f,
                                                getHeight() * 0.5f,
                                                getWidth() - 6,
                                                (float) (getHeight() * 0.5 - 3));
        g2.setPaint(gp2);
        g2.fill(rf2);
        g2.setPaint(gp1);
        g2.fill(rf1);
}


Instance 23

Class260.render(Graphics og)#1{
        Color c = new Color(colour.getRed(), colour.getGreen(), 
                  colour.getBlue());
        g.setColor(c);
        g.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
                  RenderingHints.VALUE_ANTIALIAS_ON);
        g.fill(topPoly);
        g.setColor(colour);
        g.fill(bottomPoly);
        g.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
                  RenderingHints.VALUE_ANTIALIAS_OFF);          
        g.setColor(Color.black);
        g.draw(strokeRect);
}


Instance 24

Class610.paintForegroundDisabledAndFinished(Graphics2D g)#1{
    rect = decodeRect1();
    g.setPaint(decodeGradient9(rect));
    g.fill(rect);
    rect = decodeRect2();
    g.setPaint(decodeGradient10(rect));
    g.fill(rect);
}


Instance 25

Class610.paintForegroundDisabled(Graphics2D g)#2{
    rect = decodeRect3();
    g.setPaint(decodeGradient9(rect));
    g.fill(rect);
    rect = decodeRect4();
    g.setPaint(decodeGradient10(rect));
    g.fill(rect);
}


Instance 26

Class610.paintBackgroundSelectedAndFocused(Graphics2D g)#1{
    path = decodePath1();
    g.setPaint(decodeGradient10(path));
    g.fill(path);
    path = decodePath10();
    g.setPaint(decodeGradient9(path));
    g.fill(path);
    path = decodePath11();
}


Instance 27

Class610.paintForegroundEnabledAndFinished(Graphics2D g)#0{
    rect = decodeRect1();
    g.setPaint(decodeGradient5(rect));
    g.fill(rect);
    rect = decodeRect2();
    g.setPaint(decodeGradient6(rect));
    g.fill(rect);
}


Instance 28

Class690.paintBackgroundEnabled(Graphics2D g){
    path = decodePath1();
    g.setPaint(decodeGradient1(path));
    g.fill(path);
    path = decodePath2();
    g.setPaint(decodeGradient2(path));
    g.fill(path);
}


Instance 29

Class560.paintBackgroundDisabled(Graphics2D g){
    rect = decodeRect1();
    g.setPaint(decodeGradient3(rect));
    g.fill(rect);
    rect = decodeRect2();
    g.setPaint(decodeGradient4(rect));
    g.fill(rect);
}


Instance 30

Class0.paintBackgroundSelectedAndPressedAndFocused(Graphics2D g)#0{
    path = decodePath12();
    g.setPaint(decodeGradient13(path));
    g.fill(path);
    path = decodePath13();
    g.setPaint(decodeGradient14(path));
    g.fill(path);
    path = decodePath14();
}


Instance 31

Class650.paintBackgroundSelectedAndMouseOver(Graphics2D g){
    path = decodePath8();
    g.setPaint(decodeGradient11(path));
    g.fill(path);
    path = decodePath9();
    g.setPaint(decodeGradient12(path));
    g.fill(path);
}


Instance 32

Class440.paintBackgroundDisabledAndEditable(Graphics2D g)#1{
    g.setPaint(color1);
    g.fill(path);
    path = decodePath2();
    g.setPaint(decodeGradient1(path));
    g.fill(path);
    path = decodePath3();
}


Instance 33

Class440.paintBackgroundDisabledAndEditable(Graphics2D g)#2{
    g.setPaint(color4);
    g.fill(path);
    path = decodePath4();
    g.setPaint(decodeGradient2(path));
    g.fill(path);
}


Instance 34

Class180.paintBackgroundSelectedAndPressed(Graphics2D g){
    path = decodePath8();
    g.setPaint(decodeGradient13(path));
    g.fill(path);
    path = decodePath9();
    g.setPaint(decodeGradient14(path));
    g.fill(path);
}


Instance 35

Class90.paintBackgroundSelectedAndDisabled(Graphics2D g){
    path = decodePath7();
    g.setPaint(decodeGradient7(path));
    g.fill(path);
    path = decodePath2();
    g.setPaint(decodeGradient9(path));
    g.fill(path);
}


Instance 36

Class510.paintBackgroundDisabled(Graphics2D g){
    path = decodePath5();
    g.setPaint(decodeGradient7(path));
    g.fill(path);
    path = decodePath6();
    g.setPaint(decodeGradient8(path));
    g.fill(path);
}


Instance 37

Class200.paintBackgroundEnabledAndMouseOver(Graphics2D g){
    path = decodePath1();
    g.setPaint(decodeGradient3(path));
    g.fill(path);
    path = decodePath2();
    g.setPaint(decodeGradient4(path));
    g.fill(path);
}


Instance 38

Class590.paintBackgroundEnabledAndPressed(Graphics2D g){
    path = decodePath3();
    g.setPaint(decodeGradient5(path));
    g.fill(path);
    path = decodePath4();
    g.setPaint(decodeGradient6(path));
    g.fill(path);
}


Instance 39

Class410.paintForegroundEnabled(Graphics2D g)#1{
    rect = decodeRect3();
    g.setPaint(decodeGradient5(rect));
    g.fill(rect);
    rect = decodeRect4();
    g.setPaint(decodeGradient6(rect));
    g.fill(rect);
}


Instance 40

Class240.paintBackgroundEnabled(Graphics2D g){
    rect = decodeRect1();
    g.setPaint(decodeGradient1(rect));
    g.fill(rect);
    rect = decodeRect2();
    g.setPaint(decodeGradient2(rect));
    g.fill(rect);
}


Instance 41

Class110.createDiagonalUp(Color c)#1{
        g2.fill(new Polygon(new int[] {a/2, a, a}, new int[] {a, a/2, a}, 3));
        g2.fill(new Polygon(new int[] {0, a/2, a, 0}, new int[] {a/2, 0, 0, a}, 4));
        return new TexturePaint(bi, new Rectangle(0, 0, a, a));
}


Instance 42

Class280.begin(Entity e,Object drawState)#1{
        gr.setColor( clr.darker() );
        gr.fill( path );
        gr.scale( 0.9f, 0.9f );
        gr.setColor( clr );
        gr.fill( path );
        gr.setTransform( popped );
}


Instance 43

Class80.print(Graphics g,PageFormat pageFormat,int pageIndex)#2{
    Rectangle2D.Double rect = new Rectangle2D.Double();
    rect.setFrame(0, pageheight - ymargin, pagewidth, ymargin);
    g2d.fill(rect);
    rect.setFrame(pagewidth - xmargin, 0, xmargin, pageheight);
    g2d.fill(rect);
}


Instance 44

Class420.fillLiteShape(Graphics2D g,LiteShape2 shape)#0{
        if(shape.getGeometry() instanceof MultiPolygon && shape.getGeometry().getNumGeometries() > 1) {
            MultiPolygon mp = (MultiPolygon) shape.getGeometry();
            for (int i = 0; i < mp.getNumGeometries(); i++) {
                Polygon p = (Polygon) mp.getGeometryN(i);
                try {
                    g.fill(new LiteShape2(p, null, null, false, false));
                } catch(Exception e) {
                    // should not really happen, but anyways
                    throw new RuntimeException("Unexpected error occurred while rendering a multipolygon", e);
                }
            }
        } else {
            g.fill(shape);
        }
}


Instance 45

Class430.paintComponent(final Graphics g)#3{
        final Ellipse2D circle2 = new Ellipse2D.Double(two.getX() - 6,
                two.getY() - 5, 10, 10);
        g2.draw(circle1);
        g2.fill(circle1);
        g2.draw(circle2);
        g2.fill(circle2);
        final Line2D line = new Line2D.Double(one, two);
}


Instance 46

Class200.paintComponent(Graphics graphics)#0{
      g2.setColor(this.getBackground());
      g2.fill(rect);
      g2.setColor(this.getBackground());
      g2.fill(rect);
    g2.dispose();
}


Instance 47

Class320.drawPoints(Graphics2D g,Iterable<Point> points)#4{
        g.setColor(Color.BLUE);
        g.fill(onCurves);
        g.setColor(Color.RED);
        g.fill(offCurves);
}


Instance 48

Class230.drawBaggle(Graphics2D g,BuggleWorldCell cell)#6{
      g.fill(new Arc2D.Double(padx+ox+pad, pady+oy+pad, d, d, 0, 360, Arc2D.CHORD));
      g.setColor(getCellColor(cell.getX(), cell.getY()));
      g.fill(new Arc2D.Double(padx+ox+pad2, pady+oy+pad2, d2, d2, 0, 360, Arc2D.CHORD));
}


Instance 49

Class220.paintUpDownArrowsIcon(Graphics2D graphics)#0{
        graphics.setColor(this.isDarkColorScheme ? WidgetBaseColors.DARK_FONT_COLOR : WidgetBaseColors.LIGHT_FONT_COLOR);
        graphics.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
        graphics.translate(upArrowX, upArrowY);
        graphics.fill(createUpArrow(arrowSideLength));
        graphics.translate(0, verticalDistanceBetweenArrows);
        graphics.fill(createDownArrow(arrowSideLength));
}


Instance 50

Class70.paintBackground(Graphics g,JComponent component)#0{
      final RoundRectangle2D rectangleRounded = new RoundRectangle2D.Double( 0, 0, getWidth(), getHeight() * 2, 8, 8 );
      g2D.fill( rectangleRounded );
      final RoundRectangle2D rectangleRounded = new RoundRectangle2D.Double( 0, 0, getWidth() * 2, getHeight(), 8, 8 );
      g2D.fill( rectangleRounded );
    g2D.dispose();
}


Instance 51

Class220.paintColorBlob(final Graphics2D g,final Color color)#0{
            g.setColor(Color.white);
            g.fill(BlobShape);
            g.setColor(color);
            g.fill(BlobShape);
            g.setColor(Color.gray);
            g.draw(BlobShape);
}


Instance 52

Class650.drawVertexRectangles(Graphics2D g2d)#1{
      g2d.fill(new Rectangle2D.Double(v0.x - vertexDrawSize / scale,
          v0.y - vertexDrawSize / scale, vertexDrawSize * 2 / scale,
          vertexDrawSize * 2 / scale));
      g2d.fill(new Rectangle2D.Double(v1.x - vertexDrawSize / scale,
          v1.y - vertexDrawSize / scale, vertexDrawSize * 2 / scale,
          vertexDrawSize * 2 / scale));
}


Instance 53

Class210.paintDecoration(final Graphics2D g,final Graphics2D gstroke,final double x0,final double y0,final double x1,final double y1,double dx,double dy,double dxn,double dyn)#3{
    shape.addPoint((int)x1, (int)y1);
    g.fill(shape);
}


Instance 54

Class490.paintComponent(Graphics g)#0{
      UIUtil.drawLine(g2, (int)line.getX1(), (int)line.getY1(), (int)line.getX2(), (int)line.getY2());
      final Shape arrow = LineEndDecorator.getArrowShape(line, line.getP2());
      g2.fill(arrow);
      g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, old);
}


Instance 55

Class420.paintComponent(Graphics g2d)#2{
          g.fillRoundRect((int)dialog.getX(), (int)dialog.getY() - 5, (int)dialog.getWidth(), (int)(5 + dialog.getHeight()), 5, 5);
          g.fill(dialog);
        paintShadowFromParent(g);
}


Instance 56

Class400.paint(Graphics2D g2)#1{
            g2.fill(transformArea(ra, entry.getKey()));
                    new ImmutablePoint((int)ra.getBounds2D().getCenterX(), (int)ra.getBounds2D().getCenterY()), Color.WHITE, null);
}


Instance 57

Class20.paintArrowhead(Graphics2D g2D,Point p1,Point p2,Double arrowheadPlacement2,Color casingColor,Color fillColor)#3{
        head = AffineTransform.getRotateInstance(angle).createTransformedShape(head);
        head = AffineTransform.getTranslateInstance(pTip.x, pTip.y).createTransformedShape(head);
        g2D.fill(head);
}


Instance 58

Class20.paintArrowhead(Graphics2D g2D,Point p1,Point p2,Double arrowheadPlacement2,Color casingColor,Color fillColor)#1{
        headCore = AffineTransform.getRotateInstance(angle).createTransformedShape(headCore);
        headCore = AffineTransform.getTranslateInstance(pTip.x, pTip.y).createTransformedShape(headCore);
        g2D.fill(headCore);
}


Instance 59

Class660.paintChannel(final Channel channel,final Graphics2D g,final MapView mv)#2{
        double angle = angleFromXAxis(fromPoint, toPoint);
        head = AffineTransform.getRotateInstance(angle).createTransformedShape(head);
        head = AffineTransform.getTranslateInstance(toPoint.x, toPoint.y).createTransformedShape(head);
        g.fill(head);
}


Instance 60

Class280.paintComponent(Graphics g)#0{
      for (Point2D p: points) {
        r.setRect(p.getX(), p.getY(), 1, 1);
        g2.fill(r);
      }
}


Instance 61

Class260.drawArrowHead(final Graphics2D aCanvas,final int aXpos,final int aYpos,final int aDirection,final int aArrowWidth,final int aArrowHeight)#1{
    final Polygon arrowHead = new Polygon();
    arrowHead.addPoint( x1, y2 );
    aCanvas.fill( arrowHead );
}


Instance 62

Class710.replay(final WmfFile file)#2{
        g2.fill( getScaledBounds() );
}


Instance 63

Class710.replay(final WmfFile file)#5{
        g2.fill( getScaledBounds() );
}


Instance 64

Class710.replay(final WmfFile file)#10{
        g2.fill( getScaledBounds() );
}


Instance 65

Class190.draw(Graphics2D g,boolean showAnchors)#0{
         for (int i = 0; i < anchors.length; i++) {
            g.fill(anchors[i]);
         }
}


Instance 66

Class440.fillPolyPolygon(Graphics2D g2d,List pols)#0{
            for (int i = 0; i < pols.size(); i++) {
                Polygon2D pol = (Polygon2D)(pols.get(i));
                path.append(pol, false);
            }
            g2d.fill(path);
}


Instance 67

Class520.drawSeries(Graphics2D g2,Rectangle2D dataArea,PlotRenderingInfo info,PolarPlot plot,XYDataset dataset,int seriesIndex)#2{
            g2.setComposite(AlphaComposite.getInstance(
                    AlphaComposite.SRC_OVER, 0.5f));
            g2.fill(poly);
            g2.setComposite(savedComposite);
}


Instance 68

Class280.yellowHighlight(Image image,Collection<Rectangle> boxes,float outsetFactor)#7{
        box.grow((int) (box.getHeight() * outsetFactor),
            (int) (box.getWidth() * outsetFactor));
      g2d.fill(box);
    g2d.setComposite(originalComposite);
}


Instance 69

Class230.createDiagonalCheck(Color c)#0{
        g2.fill(new Polygon(new int[] {a/2, a, a/2, 0}, new int[] {0, a/2, a, a/2}, 4));
        return new TexturePaint(bi, new Rectangle(0, 0, a, a));
}


Instance 70

Class220.paintImage(Graphics2D g2d,Color color)#0{
        Color bcolor = new Color(1f, 1f, 1f, 0f);
        g2d.setBackground(bcolor);
        g2d.fill(path);
        g2d.clearRect(0, 16, 40, 8);
}


Instance 71

Class120.runTest(Object ctx,int numReps)#1{
                ellipse.setFrame(x, y, size, size);
                g2d.fill(ellipse);
}


Instance 72

Class500.fillCircle(final Ellipse2D ell,final IPoint pt,final double width,final Graphics2D g){
    ell.setFrame(pt.getX()-width/2., pt.getY()-width/2., width, width);
    g.fill(ell);
}


Instance 73

Class620.paint(Graphics2D g2d)#2{
        Area area2 = new Area(outSquare);
        area2.subtract(new Area(midSquare));
        g2d.fill(area2);
}


Instance 74

Class620.paint(Graphics2D g2d)#3{
        Area area = new Area(midSquare);
        area.subtract(new Area(inSquare));
        g2d.fill(area);
}


Instance 75

Class120.paintComponent(Graphics g)#0{
        g2.fill(g.getClipBounds());
        paintGrid(g2);
        AffineTransform originalTransform = g2.getTransform();
}


Instance 76

Class100.paintComponent(Graphics g)#4{
        g2.fill(g.getClipBounds());
        AffineTransform originalTransform = g2.getTransform();
}


Instance 77

Class20.paint(Component c,Graphics2D g)#4{
    g.setStroke(PainterUtils.DEFAULT_STROKE);
    g.fill(dot);
}


Instance 78

Class180.renderElement(StyleGroup group,Graphics2D g,Camera camera,GraphicElement element)#1{
    shape.setFrame(pos.x - w2, pos.y - h2, width, height);
    g.fill(shape);
    renderText(group, g, camera, element);
}


Instance 79

Class380.drawTab(Graphics g,int left,int right,boolean leftNotch,boolean rightNotch)#0{
    g2.fill(Toolkit.createRoundRect(left, TAB_TOP,
                                    right, TAB_BOTTOM,
                                    leftNotch ? CURVE_RADIUS : 0,
                                    rightNotch ? CURVE_RADIUS : 0,
                                    0, 0));
}


Instance 80

Class530.paint(Component c,Graphics2D g2)#3{
        g2.setStroke(DEFAULT_STROKE);
        g2.fill(dot);
}


Instance 81

Class130.renderElement(StyleGroup group,Graphics2D g,Camera camera,GraphicElement element)#1{
    shape.setFrame(node.x - w2, node.y - h2, width, height);
    g.fill(shape);
    renderText(group, g, camera, element);
}


Instance 82

Class160.drawTab(Graphics g,int left,int right,boolean leftNotch,boolean rightNotch)#0{
      g2.fill(Toolkit.createRoundRect(left, TAB_TOP, right, TAB_BOTTOM, 0, 0,
                                      rightNotch ? CURVE_RADIUS : 0,
                                      leftNotch ? CURVE_RADIUS : 0));
}


Instance 83

Class250.drawV(boolean immediate)#1{
    gV.setBackground(Color.white);
    gV.fill(gV.getClipBounds());
    renderGrid.renderVertView(gV, atI);
}


Instance 84

Class730.draw(Graphics2D g)#0{
            g.fill(getBounds().getRectangle2D());
        g.clip(getBounds().getRectangle2D());
}


Instance 85

Class430.fill(Graphics2D g2d){
        final Shape old = g2d.getClip();
        g2d.clip(clip);
        g2d.fill(area);
        g2d.setClip(old);
}


Instance 86

Class350.drawPoint(Graphics2D g2,double x,double y,double r,Color color,boolean hasBorder)#2{
    c.setFrame(x - r, y - r, w, w);
    g2.fill(c);
}


Instance 87

Class230.renderMap(@Nonnull Map map,@Nonnull Rectangle viewport,int level,@Nonnull Graphics2D g)#0{
                                renderTile(xdisp, ydisp, g, t.getImg()[0]);
                                renderOverlay(g, mt);
                                    g.fill(getTilePolygon());
        g.setTransform(transform);
}


Instance 88

Class690.paintBorder(final Component c,Graphics g,final int x,final int y,final int width,final int height)#1{
            ((Graphics2D)g).fill(getCapsLockShape());
}


Instance 89

Class690.paintBackground(Graphics g,Dimension size,Color background,int state)#10{
        ((Graphics2D)g).fill(getShape(size));
}


Instance 90

Class690.paintBackground(Graphics g,Dimension size,Color background,int state)#11{
          ((Graphics2D)g).fill(getShape(size));
}


Instance 91

Class690.paintBackground(Graphics g,Dimension size,Color background,int state)#27{
          ((Graphics2D)g).fill(getShape(size));
}


Instance 92

Class690.paint(Graphics g,JComponent c)#9{
    ((Graphics2D)g).fill(path);
}


Instance 93

Class510.drawFill(Graphics2D g){
        g.fill(getPath());
}


Instance 94

Class630.drawFill(Graphics2D g){
    g.fill(getTransformedShape());
}


Instance 95

Class200.paint(Graphics g)#0{
            Shape shape = perspectiveTransformer.perspectiveTransform(rectangle);
            g2d.fill(shape);
}


Instance 96

Class200.drawFill(Graphics2D g)#1{
            g.fill(ellipse);
}


Instance 97

Class200.paintImage(Graphics2D graphics2d,Color color)#1{
        GeneralPath path = new GeneralPath();
        draw(path);
        g2d.fill(path);
}


Instance 98

Class570.drawFill(Graphics2D g){
        g.fill(bounds);
}


Instance 99

Class10.draw(Graphics2D graphics,Paint_Delegate paintDelegate)#2{
                                graphics.fill(arc);
}


Instance 100

Class10.fill(Graphics2D g2d){
            g2d.fill(getShape());
}


Instance 101

Class400.drawFill(Graphics2D g)#0{
        double grow = AttributeKeys.getPerpendicularFillGrowth(this);
        Geom.grow(r, grow, grow);
        g.fill(r);
}


Instance 102

Class480.drawPreview(Graphics2D g2d,Dimension dimension,MapView mv){
        g2d.fill(shape);
}


Instance 103

Class480.paintAreaHighlight(Graphics2D g2)#3{
            g2.fill(transformArea(area, selectedFeaturePointer.getPosition()));
}


Instance 104

Class250.draw(Graphics2D graphics,Paint_Delegate paintDelegate)#3{
                            graphics.fill(shape);
}


Instance 105

Class590.paintComponent(Graphics g)#2{
      ((Graphics2D) g).fill(rect);
}


Instance 106

Class590.paintShape(Graphics2D g,AffineTransform t)#1{
            g.fill (createPoly (t));
}


Instance 107

Class120.paintLastGhost(Graphics2D g2d)#1{
    g2d.fill(path.getShape());
}


Instance 108

Class350.paintStrips(Graphics2D g,List<ATEAnalysisItem> items)#1{
            g.fill(composeIndicatorRectangle(item.line, 0));
}


Instance 109

Class550.processFillShape(Graphics2D g){
    g.fill(readShape());
}


Instance 110

Class170.drawRectangle(Graphics2D g,Color fill,Color stroke)#3{
                g.fill(r);
}


Instance 111

Class170.replay(final WmfFile file)#3{
      graph.fill( rec );
}


Instance 112

Class170.paintComponent(final Graphics g)#0{
        g2d.fill ( getProgressShape () );
        GraphicsUtils.restoreAntialias ( g2d, aa );
}


Instance 113

Class240.drawRect(Graphics2D g,int color,double w1,double h1,double w2,double h2,boolean useLatlon)#0{
    double hmin = Math.min(h1, h2);
    double height = Math.abs(h1 - h2);
    rect.setRect(wmin, hmin, width, height);
    g.fill(rect);
}


Instance 114

Class20.paint(Graphics g,Divider divider)#0{
                g2d.fill(divider.getBounds());
}


Instance 115

Class540.closePath(Graphics2D g,Path2D.Double path,double previousX,Rectangle2D bounds,double yTopMargin)#0{
      double yBottomOfArea = bounds.getY() + bounds.getHeight() - yTopMargin;
      path.lineTo(previousX, yBottomOfArea);
      path.closePath();
      g.fill(path);
}


Instance 116

Class540.drawFill(Graphics2D g)#2{
            g.fill(r);
}


Instance 117

Class300.paintBorder(final Graphics g,final int x,final int y,final int w,final int h)#2{
            ((Graphics2D)g).fill(area);
}


Instance 118

Class60.paintIcon(Component c,Graphics g,int x,int y)#6{
                    g2.fill(path);
}


Instance 119

Class60.drawGeometry(Geometry g,Graphics2D g2,int series,int item,Rectangle2D dataArea,XYPlot plot,ValueAxis domainAxis,ValueAxis rangeAxis)#4{
                g2.fill(new TranslatedLiteShape(g, dataArea, plot, domainAxis, rangeAxis));
}


Instance 120

Class190.draw(Graphics2D g,boolean showAnchors)#9{
         g.fill(shape);
}


Instance 121

Class190.paint(Graphics g)#8{
            g2d.fill(lens);
}


Instance 122

Class600.drawFill(Graphics2D g)#1{
            g.fill(getPath());
}


Instance 123

Class600.paintComponent(Graphics g)#10{
    ((Graphics2D)g).fill(arrow);
}


Instance 124

Class340.main(String[] args)#0{
    g.fill(stroke.createStrokedShape(shape));
}


Instance 125

Class390.paintComponent(Graphics g)#11{
                g2.fill(noteRect);
}


Instance 126

Class390.replay(final WmfFile file)#4{
      graph.fill( genPath );
}


Instance 127

Class330.replay(final WmfFile file)#4{
      graph.fill( arc );
}


Instance 128

Class330.replay(final WmfFile file)#6{
      graph.fill( ellipse );
}


Instance 129

Class710.paint(Graphics g)#2{
                ((Graphics2D)g).fill(arrowShape);
}


Instance 130

Class30.drawFill(Graphics2D g)#2{
            g.fill(r);
}


Instance 131

Class450.drawFill(Graphics2D g)#1{
            g.fill(roundrect.getBounds2D());
}


Instance 132

Class450.drawFill(Graphics2D g)#2{
            g.fill(roundrect);
}


Instance 133

Class440.fillPolyPolygon(Graphics2D g2d,List pols)#4{
            g2d.fill((Polygon2D)(pols.get(0)));
}


Instance 134

Class150.drawSpline(Graphics g,float[] xpoints,float[] ypoints,int npoints,boolean closed,boolean fill,boolean isActiveOverlayRoi)#3{
        g2d.fill(path);
}


Instance 135

Class640.paintComponent(final Graphics g)#2{
        g2.fill(getArrow(this.type));
}


Instance 136

Class640.fillPoint(Graphics2D g,Point2D p){
        Shape shape = getPointShape(p);
        g.fill(shape);
}


Instance 137

Class430.paint(Graphics g)#3{
                ((Graphics2D) g).fill(_arrowShape);
}


Instance 138

Class180.paintComponent(Graphics g)#3{
                        g2d.rotate(Math.PI+Math.PI/2,this.getWidth()/2.0,this.getHeight()/2.0);
                    g2d.fill(shape);
}


Instance 139

Class380.paintComponent(Graphics g)#8{
        g2d.fill(area);
}


Instance 140

Class660.paintComponent(Graphics g)#4{
        g2.fill(getBounds());
}


Instance 141

Class660.replay(final WmfFile file)#5{
      graph.fill( polygon );
}


Instance 142

Class530.paintOutputPart(DisplayedGem displayedGem,Graphics2D g2d)#5{
        Polygon bindPoint = displayedGem.getDisplayedGemShape().getOutputShape();
        g2d.fill(bindPoint);
}


Instance 143

Class530.drawToken(DBInputTextTokenInfo info,Graphics2D g,Color c,boolean fill)#6{
                    g.fill(gp);
}


Instance 144

Class500.paint(Graphics g)#3{
        g2.fill(resize);
}


Instance 145

Class460.fillSelectionAndBorder(Graphics2D g,JBTabsImpl.ShapeInfo selectedShape,Color tabColor,int x,int y,int height)#2{
    g.fill(selectedShape.fillPath.getShape());
}


Instance 146

Class50.paint(Graphics g)#1{
        g2.fill(reformThumbShape(this.getWidth(), this.getHeight(), (int) viewExtent));
}


Instance 147

Class560.drawFill(Graphics2D g)#2{
                g.fill(path);
}


Instance 148

Class160.drawCoordinate(Coordinate c,Graphics2D g2,int series,int item,Rectangle2D dataArea,XYPlot plot,ValueAxis domainAxis,ValueAxis rangeAxis)#1{
            g2.fill(shape);
}


Instance 149

Class160.paint(Graphics g,HandleGesture gesture)#1{
            ((Graphics2D) g).fill(curve);
}


Instance 150

Class520.replay(final WmfFile file)#2{
      graph.fill( shape );
}


Instance 151

Class520.replay(final WmfFile file)#0{
      graph.fill( rect );
}


Instance 152

Class90.drawFill(Graphics2D g){
        g.fill(getTextShape());
}


Instance 153

Class110.draw(Graphics2D graphics,float x,float y)#4{
                graphics.fill(fShape);
}


Instance 154

Class700.drawFill(Graphics2D g){
        g.fill(ellipse);
}


Instance 155

Class70.replay(final WmfFile file)#1{
    final MfLogRegion reg = file.getRegionObject( getRegion() );
    g2.fill( reg.getBounds() );
}


Instance 156

Class470.renderArrow(StyleGroup group,Graphics2D g,Camera camera,GraphicEdge edge)#0{
        shape.reset();
        shape.moveTo(x, y);
        shape.lineTo(x - theDirection.data[0] - perp.data[0], y
            - theDirection.data[1] - perp.data[1]);
        shape.closePath();
        g.fill(shape);
}